/**
 * 后端图片URL处理工具函数
 */

import ServiceIntegration from '../models/ServiceIntegration.js';

// 缓存静态图片URL模板
let staticImageUrlTemplate = null;
let templateLoadTime = 0;
const CACHE_DURATION = 5 * 60 * 1000; // 5分钟缓存

/**
 * 加载静态图片URL模板
 */
async function loadStaticImageUrlTemplate() {
  try {
    const service = await ServiceIntegration.getByServiceName('system_a');
    if (service && service.api_config && service.api_config.staticImage) {
      staticImageUrlTemplate = service.api_config.staticImage.urlTemplate || '';
    } else {
      staticImageUrlTemplate = '';
    }
    templateLoadTime = Date.now();
  } catch (error) {
    console.error('加载静态图片URL模板失败:', error);
    staticImageUrlTemplate = '';
    templateLoadTime = Date.now();
  }
}

/**
 * 获取静态图片URL模板（带缓存）
 */
async function getStaticImageUrlTemplate() {
  const now = Date.now();
  
  // 如果缓存过期或未加载，重新加载
  if (staticImageUrlTemplate === null || (now - templateLoadTime) > CACHE_DURATION) {
    await loadStaticImageUrlTemplate();
  }
  
  return staticImageUrlTemplate || '';
}

/**
 * 生成完整的图片URL
 * @param {string} filename 文件名或相对路径
 * @returns {Promise<string>} 完整的图片URL
 */
export async function generateImageUrl(filename) {
  if (!filename) return '';
  
  // 如果已经是完整URL，直接返回
  if (filename.startsWith('http://') || filename.startsWith('https://')) {
    return filename;
  }
  
  // 获取URL模板
  const template = await getStaticImageUrlTemplate();
  
  if (!template) {
    // 如果没有配置模板，返回相对路径（兼容现有逻辑）
    return filename.startsWith('/') ? filename : `/${filename}`;
  }
  
  // 使用模板生成完整URL
  return template.replace('{filename}', filename.replace(/^\/+/, ''));
}

/**
 * 生成完整的图片URL（同步版本，使用缓存）
 * @param {string} filename 文件名或相对路径
 * @returns {string} 完整的图片URL
 */
export function generateImageUrlSync(filename) {
  if (!filename) return '';
  
  // 如果已经是完整URL，直接返回
  if (filename.startsWith('http://') || filename.startsWith('https://')) {
    return filename;
  }
  
  // 如果模板还未加载或已过期，返回相对路径
  const now = Date.now();
  if (staticImageUrlTemplate === null || (now - templateLoadTime) > CACHE_DURATION) {
    return filename.startsWith('/') ? filename : `/${filename}`;
  }
  
  if (!staticImageUrlTemplate) {
    // 如果没有配置模板，返回相对路径
    return filename.startsWith('/') ? filename : `/${filename}`;
  }
  
  // 使用模板生成完整URL
  return staticImageUrlTemplate.replace('{filename}', filename.replace(/^\/+/, ''));
}

/**
 * 批量生成图片URL
 * @param {string[]} filenames 文件名数组
 * @returns {Promise<string[]>} 完整图片URL数组
 */
export async function generateImageUrls(filenames) {
  if (!filenames || filenames.length === 0) return [];
  
  const template = await getStaticImageUrlTemplate();
  
  return filenames.map(filename => {
    if (!filename) return '';
    
    // 如果已经是完整URL，直接返回
    if (filename.startsWith('http://') || filename.startsWith('https://')) {
      return filename;
    }
    
    if (!template) {
      // 如果没有配置模板，返回相对路径
      return filename.startsWith('/') ? filename : `/${filename}`;
    }
    
    // 使用模板生成完整URL
    return template.replace('{filename}', filename.replace(/^\/+/, ''));
  });
}

/**
 * 处理专家数据中的图片URL
 * @param {object} expert 专家数据对象
 * @returns {Promise<object>} 处理后的专家数据
 */
export async function processExpertImageUrls(expert) {
  if (!expert) return expert;
  
  const processedExpert = { ...expert };
  
  // 处理头像URL
  if (processedExpert.avatar_url) {
    processedExpert.avatar_url = await generateImageUrl(processedExpert.avatar_url);
  }
  
  // 处理展示图片URLs
  if (processedExpert.display_images && Array.isArray(processedExpert.display_images)) {
    processedExpert.display_images = await generateImageUrls(processedExpert.display_images);
  }
  
  return processedExpert;
}

/**
 * 处理专家数据中的图片URL（同步版本）
 * @param {object} expert 专家数据对象
 * @returns {object} 处理后的专家数据
 */
export function processExpertImageUrlsSync(expert) {
  if (!expert) return expert;
  
  const processedExpert = { ...expert };
  
  // 处理头像URL
  if (processedExpert.avatar_url) {
    processedExpert.avatar_url = generateImageUrlSync(processedExpert.avatar_url);
  }
  
  // 处理展示图片URLs
  if (processedExpert.display_images && Array.isArray(processedExpert.display_images)) {
    processedExpert.display_images = processedExpert.display_images.map(url => 
      generateImageUrlSync(url)
    );
  }
  
  return processedExpert;
}

/**
 * 处理管理员数据中的图片URL
 * @param {object} admin 管理员数据对象
 * @returns {Promise<object>} 处理后的管理员数据
 */
export async function processAdminImageUrls(admin) {
  if (!admin) return admin;
  
  const processedAdmin = { ...admin };
  
  // 处理头像URL（如果管理员有头像字段）
  if (processedAdmin.avatar) {
    processedAdmin.avatar = await generateImageUrl(processedAdmin.avatar);
  }
  
  return processedAdmin;
}

/**
 * 处理用户数据中的图片URL
 * @param {object} user 用户数据对象
 * @returns {Promise<object>} 处理后的用户数据
 */
export async function processUserImageUrls(user) {
  if (!user) return user;
  
  const processedUser = { ...user };
  
  // 处理头像URL
  if (processedUser.avatar) {
    processedUser.avatar = await generateImageUrl(processedUser.avatar);
  }
  
  return processedUser;
}

/**
 * 清除缓存的URL模板（用于配置更新后）
 */
export function clearImageUrlTemplateCache() {
  staticImageUrlTemplate = null;
  templateLoadTime = 0;
}

/**
 * 预加载图片URL模板（可在应用启动时调用）
 */
export async function preloadImageUrlTemplate() {
  await getStaticImageUrlTemplate();
}

/**
 * 从完整URL中提取文件名
 * @param {string} url 完整的图片URL
 * @returns {string} 文件名
 */
export function extractFilenameFromUrl(url) {
  if (!url) return '';
  
  // 如果是相对路径，直接返回
  if (!url.startsWith('http://') && !url.startsWith('https://')) {
    return url.replace(/^\/+/, '');
  }
  
  try {
    const urlObj = new URL(url);
    const pathname = urlObj.pathname;
    return pathname.split('/').pop() || '';
  } catch (error) {
    console.error('解析URL失败:', error);
    return '';
  }
}
